package com.ali.config;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * 反射处理器
 */
public class ReflectionHandler {
    /**
     * 获取可访问的属性
     */
    public static Field[] getFields(Class<?> clazz) {
        return clazz.getFields();
    }

    /**
     * 获取类的属性
     */
    public static Field[] getDeclaredFields(Class<?> clazz) {
        return clazz.getDeclaredFields();
    }

    /**
     * 获取可访问的方法
     */
    public static Method[] getMethods(Class<?> clazz) {
        return clazz.getMethods();
    }

    /**
     * 获取类的方法
     */
    public static Method[] getDeclaredMethods(Class<?> clazz) {
        return clazz.getDeclaredMethods();
    }

    /**
     * 获取对象
     */
    public static <T> T getObject(Class<?> clazz) {
        try {
            Object object = clazz.getDeclaredConstructor().newInstance();
            return (T) object;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 调用可访问的无参方法
     */
    public static Object invokeNotParamMethod(Object object, String methodName) {
        try {
            Class<?> clazz = getClass(object);
            //获取方法
            Method method = clazz.getMethod(methodName);
            //取消语言访问检查
            method.setAccessible(true);
            //调用方法
            if (object != null) {
                return method.invoke(object);
            }
            return null;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取类的字节文件对象
     */
    private static Class<?> getClass(Object object) {
        if (object != null) {
            return object.getClass();
        }
        return null;
    }

    /**
     * 调用可访问的有参方法
     */
    public static Object invokeParamMethod(Object object, String methodName, Object value) {
        try {
            Class<?> clazz = getClass(object);
            //获取方法
            Method method = null;
            if (value instanceof String) {
                method = clazz.getMethod(methodName, String.class);
            }
            //取消语言访问检查
            method.setAccessible(true);
            //调用方法
            return method.invoke(object, value);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 调用类的无参方法
     */
    public static Object invokeDeclaredNotParamMethod(Object object, String methodName) {
        try {
            Class<?> clazz = getClass(object);
            //获取方法
            Method method = clazz.getDeclaredMethod(methodName);
            //取消语言访问检查
            method.setAccessible(true);
            //调用方法
            return method.invoke(object);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 调用类的有参方法
     */
    public static Object invokeDeclaredParamMethod(Object object, String methodName, Object value) {
        try {
            Class<?> clazz = getClass(object);
            //获取方法
            Method method = null;
            if (value instanceof String) {
                method = clazz.getDeclaredMethod(methodName, String.class);
            }
            //取消语言访问检查
            method.setAccessible(true);
            //调用方法
            return method.invoke(object, value);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}